package Colisiones;


public class Colisiones {

	
		
		
	private static boolean comparar(float valor, float minimo, float maximo)
	{
		if  ((minimo <= valor) && (valor <= maximo) ) {return true;} 
		
		return false;
	}
	
	public static double norma( float x0, float y0, float x1, float y1)
	{
		return (Math.sqrt(Math.pow(x1-x0, 2)+ Math.pow(y1-y0, 2)));
	}
	
	
	public boolean rectaEnCicunferencia(Circunferencia c, Recta r)
	{
		// pienso que si una recta esta contenida en un circulo 
		// alguno de sus puntos extremos deberan esta contenidos en el
	    // entonces la distancia de uno de los extremos al centro debe ser menor 
		// que el radio del circulo
		
		 double distanciaPrimerExtremo  = norma(c.getX(),c.getY(),r.getX0(),r.getY0());
		 double distanciaSegundoExtremo = norma(c.getX(),c.getY(),r.getX1(),r.getY1());
		
		 if ((distanciaPrimerExtremo <= c.getRadio())  || ( distanciaSegundoExtremo <= c.getRadio()) )
		 {
			 return true; // la recta o una parte de ella esta adentro
		 }

		 return false;
		
	}
	
	
	
	
	
	public boolean colisionCircunferencias(Circunferencia c1, Circunferencia c2)
	{
		
		if (norma(c1.getX(),c2.getX(),c1.getY(),c2.getY())  <= c1.getRadio() + c2.getRadio())
		{
			return true;
		}
	
		return false;
		
	}
	
	public boolean colisionRectas(Recta r1, Recta r2)
	{
		double m1 = 0;
		double b1 = 0;
		double m2 = 0;
		double b2 = 0;
	
		float dX1,dY1;
		float dX2,dY2;
		
		float xInt = 0;
		float yInt = 0;
		
		float minYP1, maxYP1, minYP2, maxYP2, minXP1, maxXP1, minXP2, maxXP2;
		
		boolean e1, e2; // error que retorna true si la pendiente es infinita
		
		e1 = false; 
		e2 = false;
		
		dX1 = (r1.getX1() - r1.getX0());
		dY1 = (r1.getY1() - r1.getY0());
		
		dX2 = (r2.getX1() - r2.getX0());
		dY2 = (r2.getY1() - r2.getY0());
		
		minXP1 = minimo(r1.getX0(),r1.getX0());
		maxXP1 = maximo(r1.getX0(),r1.getX1());
		
		minYP1 = minimo(r1.getY0(),r1.getY1());
		maxYP1 = maximo(r1.getY0(),r1.getY1());
	
		minXP2 = minimo(r2.getX0(),r2.getX1());
		maxXP2 = maximo(r2.getX0(),r2.getX1());
		minYP2 = minimo(r2.getY0(),r2.getY1());
		maxYP2 = maximo(r2.getY0(),r2.getY1());
	
		
		
		
		if (dX1 != 0)
		{
			m1 = ( dY1 / dX1 );
			b1 = r1.getY0() - (r1.getX0() * m1); 		
			e1 = true;
		}
		
		if (dX2 != 0)
		{
			m2 = ( dY2 / dX2 );
			b2 = r2.getY0() - (r2.getX0() * m2); 
			e2 = true;
		}
		
		if ( (e1 == true ) && (e2 == true) ) // sin pendientes infinitas (es decir rectas no verticales)
		{			
			xInt = (float) (  (b2 - b1) /  (m1 - m2) ); 
			yInt = (float) (( m1 * xInt ) + b1);				
	
		}
		
		if (( e1 == false ) && (e2 == true)) // recta1 vertical
		{
			xInt = r1.getX0();
			yInt = (float) (( m2 * xInt ) + b2);
		}
		
		if (( e1 == true ) && (e2 == false)) // recta2 vertical
		{
			xInt = r2.getX0();
			yInt = (float) (( m1 * xInt ) + b1);
		}
		
		if (( e1 == false ) && (e2 == false)) // recta1 y recta2 verticales (paralelas)
		{
			xInt = r1.getX0();
			
	        // comparacion caso particular segmentos paralelos		
			if	((comparar(minYP2, minYP1, maxYP1)  == true) ||
				 (comparar(maxYP2,  minYP1, maxYP1) == true) ||
				 (comparar(minYP1, minYP2, maxYP2)  == true) ||
				 (comparar(maxYP1,  minYP2, maxYP2) == true) 
				)	
			{
				return true;
			}
		}
	
		// comparacion para los primeros 3 casos
		if	(
					(comparar(xInt, minXP1, maxXP1) == true) &&
					(comparar(xInt, minXP2, maxXP2) == true) &&
					(comparar(yInt, minYP1, maxYP1) == true) &&
					(comparar(yInt, minYP2, maxYP2) == true) 
				)	
			{
				return true;
			}

		return false;
	}
	
	public boolean colisionCircunferenciaRecta(Circunferencia c, Recta r)
	{
	
		if  (((comparar(c.getX(),r.getX0(),r.getX1()))  && (comparar(c.getY(),r.getY0(),r.getY1())) )  || 
			( (comparar(c.getX(),r.getX0(),r.getX1()))  && (comparar(c.getY(),r.getY1(),r.getY0())) )  || 
			( (comparar(c.getX(),r.getX1(),r.getX0()))  && (comparar(c.getY(),r.getY0(),r.getY1())) )  || 
			( (comparar(c.getX(),r.getX1(),r.getX0()))  && (comparar(c.getY(),r.getY1(),r.getY0())) )  ) 
	    
		{
			return true;
		}
		
		if (rectaEnCicunferencia(c,r) == true)
		{
			return true;
		}
		
		return false;
	}
	
	
	
	private float minimo( float d1, float d2)
	{
		if ( d1 < d2) {return d1;}
		
		return d2;
	}

	private float maximo( float d1, float d2)
	{
		if ( d1 > d2) {return d1;}
		
		return d2;
	}

	
	
	
	
}
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
//--------------------------------------- Modelo anterior (Autopartes) ---------------------------	
	
	
	
	
	
	
/*	final static int MAX = 6;
	final static int MIN = 0;
	
	public static int i,j;
	public static  int matriz[][] = new int[MAX][MAX];
	
	
	
	public static void inicializar()
	{
		matriz[1][1] = 1;
		matriz[1][2] = 1;
		matriz[2][1] = 1;
		matriz[2][2] = 1;
		matriz[3][1] = 1;
		matriz[3][2] = 1;
	
	}
	
	public static void imprimir()
	{
		System.out.println();
		for ( i = 0; i < MAX; i++)
			for ( j = 0; j < MAX; j++)
				{
					System.out.print(matriz[i][j]);
					if (j == MAX-1) { System.out.println();}
				}
			
	}
	
	private static int getAltoVehiculo()
	{
		int delta = 0;
        
        // busco el alto de automovil
        for ( i = MIN; i < MAX; i++)
    	for ( j = MIN; j < MAX; j++)
    	{
    		if ( matriz[i][j] == 1)
    		{ i++;
    		  delta++;
    		}
    	}
        return delta;
	}
	
	
	
	// dezplaza a derecha las autopartes
	// 0 es el limite a izquierda y MAX el limite a derecha
	// si esta dentro de los limites realiza el movimiento y devuelve error false
	// si se sobrepasan esos limites devuelve error true y no se dezplaza
	
	
	public static boolean desplazarHorizontalmenteDerecha()
	{
		int matrizAuxiliar[][] = new int [MAX][MAX];
		boolean error;
		
		error = false;
		for ( i = MIN; i < MAX; i++)
			for ( j = MIN; j < MAX; j++)
			{
				if ((matriz[i][j] == 1) && ( j < MAX))
				{
					if (j+1 == MAX) { return true;}
					
					if (error != true)
					{
						matrizAuxiliar[i][j+1] = matriz[i][j];
					}
				}
			}
	
		
		if (error != true ) // si no hay colision actualizar matriz
	     {
			matriz = matrizAuxiliar;	
	     }
	
		return error;
		
	}

	// desplaza a izquierda las autopartes

	public static boolean desplazarHorizontalmenteIzquierda()
	{
		int matrizAuxiliar[][] = new int [MAX][MAX];
		boolean error;
		
		error = false;
		for ( i = MIN; i < MAX; i++)
			for ( j = MIN; j < MAX; j++)
			{
				if ((matriz[i][j] == 1) && ( j > MIN-1))
				{
					if (j == MIN) { return true;}
					
					if (error != true)
					{
						matrizAuxiliar[i][j-1] = matriz[i][j];
					}
				}
			}
	
		
		if (error != true ) // si no hay colision actualizar matriz
	     {
			matriz = matrizAuxiliar;	
	     }
	
		return error;
		
	}

	
	public static void rotarDerecha()
	{

		int matrizAuxiliar[][] = new int [MAX][MAX];
        int delta;
        boolean error;
         
        error = false;
        
        
        delta = getAltoVehiculo();
        
		for ( i = MIN; i < MAX; i++)
		{
			
		
			for ( j = MIN; j < MAX; j++)
			{	
				if ((matriz[i][j] == 1))
				{
					matrizAuxiliar[i][j+delta] = matriz[i][j];
					error = true;
				}
			}
			if (error == true) { 
					delta--;
					error = false;
			}
		}
		matriz = matrizAuxiliar;
	}
	
	
	
	
	public static void main(String argv[])
	{

		boolean error = false;
		
		inicializar();
		imprimir();
	    
		while (error == false) // mientras no haya error me muevo a la derecha
		{
			error = desplazarHorizontalmenteDerecha();
			if (error == false) {imprimir();}
			else {System.out.println("\nColision a Derecha (no se modifica la matriz)");}
		    
		}
	    
		error = false;
		
		while (error == false) // mientras no haya error me muevo a la izquierda
		{
			error = desplazarHorizontalmenteIzquierda();
			if (error == false) {imprimir();}
			else {System.out.println("\nColision a Izquierda (no se modifica la matriz)");}
		    
		}
	    
		
		rotarDerecha();
		imprimir();
	}
	
	
}
*/